const { TextUtils } = require('../../../utils/text.js');

Page({
  data: {
    // 当前标签页
    currentTab: 'basic',
    
    // 标签页配置
    tabs: [
      { key: 'basic', name: '基础处理' },
      { key: 'format', name: '格式转换' },
      { key: 'analysis', name: '文本分析' },
      { key: 'generate', name: '文本生成' }
    ],
    
    // 输入文本
    inputText: '',
    
    // 处理结果
    outputText: '',
    
    // 基础处理选项
    basicOptions: [
      { key: 'uppercase', name: '转大写', icon: 'A' },
      { key: 'lowercase', name: '转小写', icon: 'a' },
      { key: 'capitalize', name: '首字母大写', icon: 'Aa' },
      { key: 'trim', name: '去除空格', icon: '✂️' },
      { key: 'reverse', name: '反转文本', icon: '🔄' },
      { key: 'removeLines', name: '去除空行', icon: '📝' }
    ],
    
    // 格式转换选项
    formatOptions: [
      { key: 'camelCase', name: '驼峰命名', icon: '🐪' },
      { key: 'snakeCase', name: '下划线命名', icon: '🐍' },
      { key: 'kebabCase', name: '短横线命名', icon: '🍖' },
      { key: 'pascalCase', name: 'Pascal命名', icon: '📐' },
      { key: 'dotCase', name: '点分命名', icon: '•' },
      { key: 'pathCase', name: '路径命名', icon: '/' }
    ],
    
    // 文本分析结果
    analysis: {
      characters: 0,
      charactersNoSpaces: 0,
      words: 0,
      lines: 0,
      paragraphs: 0,
      sentences: 0,
      readingTime: 0
    },
    
    // 生成选项
    generateOptions: {
      type: 'lorem', // lorem, random, repeat
      count: 5,
      unit: 'paragraph' // word, sentence, paragraph
    },
    
    // 历史记录
    history: [],
    
    // 显示历史记录
    showHistory: false
  },
  
  onLoad() {
    this.loadHistory();
  },
  
  /**
   * 切换标签页
   */
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({ currentTab: tab });
    
    // 如果切换到分析页面，自动分析当前文本
    if (tab === 'analysis' && this.data.inputText) {
      this.analyzeText();
    }
  },
  
  /**
   * 输入文本变化
   */
  onTextInput(e) {
    const inputText = e.detail.value;
    this.setData({ inputText });
    
    // 如果在分析页面，实时分析
    if (this.data.currentTab === 'analysis') {
      this.analyzeText();
    }
  },
  
  /**
   * 基础文本处理
   */
  processText(e) {
    const type = e.currentTarget.dataset.type;
    const { inputText } = this.data;
    
    if (!inputText.trim()) {
      wx.showToast({
        title: '请输入文本',
        icon: 'none'
      });
      return;
    }
    
    let outputText = '';
    
    try {
      switch (type) {
        case 'uppercase':
          outputText = TextUtils.toUpperCase(inputText);
          break;
        case 'lowercase':
          outputText = TextUtils.toLowerCase(inputText);
          break;
        case 'capitalize':
          outputText = TextUtils.capitalize(inputText);
          break;
        case 'trim':
          outputText = TextUtils.trim(inputText);
          break;
        case 'reverse':
          outputText = TextUtils.reverse(inputText);
          break;
        case 'removeLines':
          outputText = TextUtils.removeEmptyLines(inputText);
          break;
        default:
          throw new Error('未知的处理类型');
      }
      
      this.setData({ outputText });
      this.addToHistory(type, inputText, outputText);
      
    } catch (error) {
      wx.showToast({
        title: error.message || '处理失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 格式转换
   */
  formatText(e) {
    const type = e.currentTarget.dataset.type;
    const { inputText } = this.data;
    
    if (!inputText.trim()) {
      wx.showToast({
        title: '请输入文本',
        icon: 'none'
      });
      return;
    }
    
    let outputText = '';
    
    try {
      switch (type) {
        case 'camelCase':
          outputText = TextUtils.toCamelCase(inputText);
          break;
        case 'snakeCase':
          outputText = TextUtils.toSnakeCase(inputText);
          break;
        case 'kebabCase':
          outputText = TextUtils.toKebabCase(inputText);
          break;
        case 'pascalCase':
          outputText = TextUtils.toPascalCase(inputText);
          break;
        case 'dotCase':
          outputText = TextUtils.toDotCase(inputText);
          break;
        case 'pathCase':
          outputText = TextUtils.toPathCase(inputText);
          break;
        default:
          throw new Error('未知的格式类型');
      }
      
      this.setData({ outputText });
      this.addToHistory(type, inputText, outputText);
      
    } catch (error) {
      wx.showToast({
        title: error.message || '转换失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 分析文本
   */
  analyzeText() {
    const { inputText } = this.data;
    
    if (!inputText.trim()) {
      this.setData({
        analysis: {
          characters: 0,
          charactersNoSpaces: 0,
          words: 0,
          lines: 0,
          paragraphs: 0,
          sentences: 0,
          readingTime: 0
        }
      });
      return;
    }
    
    try {
      const analysis = TextUtils.analyzeText(inputText);
      this.setData({ analysis });
    } catch (error) {
      wx.showToast({
        title: '分析失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 生成选项变化
   */
  onGenerateOptionChange(e) {
    const { field } = e.currentTarget.dataset;
    const value = e.detail.value;
    
    this.setData({
      [`generateOptions.${field}`]: value
    });
  },
  
  /**
   * 生成文本
   */
  generateText() {
    const { generateOptions } = this.data;
    
    try {
      let outputText = '';
      
      switch (generateOptions.type) {
        case 'lorem':
          outputText = TextUtils.generateLorem(generateOptions.count, generateOptions.unit);
          break;
        case 'random':
          outputText = TextUtils.generateRandom(generateOptions.count, generateOptions.unit);
          break;
        case 'repeat':
          if (!this.data.inputText.trim()) {
            wx.showToast({
              title: '请输入要重复的文本',
              icon: 'none'
            });
            return;
          }
          outputText = TextUtils.repeatText(this.data.inputText, generateOptions.count);
          break;
        default:
          throw new Error('未知的生成类型');
      }
      
      this.setData({ outputText });
      this.addToHistory('generate', `${generateOptions.type}-${generateOptions.count}`, outputText);
      
    } catch (error) {
      wx.showToast({
        title: error.message || '生成失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 复制结果
   */
  copyResult() {
    const { outputText } = this.data;
    
    if (!outputText) {
      wx.showToast({
        title: '没有可复制的内容',
        icon: 'none'
      });
      return;
    }
    
    wx.setClipboardData({
      data: outputText,
      success: () => {
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success'
        });
      },
      fail: () => {
        wx.showToast({
          title: '复制失败',
          icon: 'none'
        });
      }
    });
  },
  
  /**
   * 使用结果作为输入
   */
  useAsInput() {
    const { outputText } = this.data;
    
    if (!outputText) {
      wx.showToast({
        title: '没有可使用的内容',
        icon: 'none'
      });
      return;
    }
    
    this.setData({ 
      inputText: outputText,
      outputText: ''
    });
    
    // 如果在分析页面，重新分析
    if (this.data.currentTab === 'analysis') {
      this.analyzeText();
    }
  },
  
  /**
   * 清空文本
   */
  clearText() {
    this.setData({
      inputText: '',
      outputText: '',
      analysis: {
        characters: 0,
        charactersNoSpaces: 0,
        words: 0,
        lines: 0,
        paragraphs: 0,
        sentences: 0,
        readingTime: 0
      }
    });
  },
  
  /**
   * 交换输入输出
   */
  swapText() {
    const { inputText, outputText } = this.data;
    
    if (!outputText) {
      wx.showToast({
        title: '没有输出文本可交换',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      inputText: outputText,
      outputText: inputText
    });
    
    // 如果在分析页面，重新分析
    if (this.data.currentTab === 'analysis') {
      this.analyzeText();
    }
  },
  
  /**
   * 显示/隐藏历史记录
   */
  toggleHistory() {
    this.setData({
      showHistory: !this.data.showHistory
    });
  },
  
  /**
   * 使用历史记录
   */
  useHistory(e) {
    const index = e.currentTarget.dataset.index;
    const historyItem = this.data.history[index];
    
    this.setData({
      inputText: historyItem.input,
      outputText: historyItem.output,
      showHistory: false
    });
    
    // 如果在分析页面，重新分析
    if (this.data.currentTab === 'analysis') {
      this.analyzeText();
    }
  },
  
  /**
   * 清除历史记录
   */
  clearHistory() {
    wx.showModal({
      title: '确认清除',
      content: '确定要清除所有历史记录吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({ history: [] });
          this.saveHistory();
          wx.showToast({
            title: '已清除历史记录',
            icon: 'success'
          });
        }
      }
    });
  },
  
  /**
   * 添加到历史记录
   */
  addToHistory(type, input, output) {
    const historyItem = {
      type,
      input: input.substring(0, 100), // 限制长度
      output: output.substring(0, 100),
      timestamp: Date.now()
    };
    
    const history = [historyItem, ...this.data.history.slice(0, 19)]; // 保留最近20条
    this.setData({ history });
    this.saveHistory();
  },
  
  /**
   * 保存历史记录
   */
  saveHistory() {
    try {
      wx.setStorageSync('text_tool_history', this.data.history);
    } catch (error) {
      console.error('保存历史记录失败:', error);
    }
  },
  
  /**
   * 加载历史记录
   */
  loadHistory() {
    try {
      const history = wx.getStorageSync('text_tool_history') || [];
      this.setData({ history });
    } catch (error) {
      console.error('加载历史记录失败:', error);
    }
  }
});